#!/usr/bin/env node

/**
 * 智能薪资计算器构建脚本
 * 用于构建和打包Electron应用程序
 */

const { execSync } = require('child_process');
const fs = require('fs');
const path = require('path');

// 颜色输出函数
const colors = {
    reset: '\x1b[0m',
    bright: '\x1b[1m',
    red: '\x1b[31m',
    green: '\x1b[32m',
    yellow: '\x1b[33m',
    blue: '\x1b[34m',
    magenta: '\x1b[35m',
    cyan: '\x1b[36m'
};

function log(message, color = colors.reset) {
    console.log(`${color}${message}${colors.reset}`);
}

function logStep(step, message) {
    log(`\n${colors.cyan}[${step}]${colors.reset} ${message}`);
}

function logSuccess(message) {
    log(`${colors.green}✓ ${message}`, colors.green);
}

function logError(message) {
    log(`${colors.red}✗ ${message}`, colors.red);
}

function logWarning(message) {
    log(`${colors.yellow}⚠ ${message}`, colors.yellow);
}

// 检查必要的文件是否存在
function checkRequiredFiles() {
    logStep('1', '检查必要文件...');
    
    const requiredFiles = [
        'package.json',
        'main.js',
        'index.html',
        'style.css',
        'script.js'
    ];
    
    let allFilesExist = true;
    
    requiredFiles.forEach(file => {
        if (fs.existsSync(file)) {
            logSuccess(`${file} 存在`);
        } else {
            logError(`${file} 不存在`);
            allFilesExist = false;
        }
    });
    
    if (!allFilesExist) {
        logError('缺少必要文件，构建终止');
        process.exit(1);
    }
}

// 创建图标文件
function createIcons() {
    logStep('2', '创建应用图标...');
    
    try {
        // 运行图标创建脚本
        execSync('node assets/create-icons.js', { stdio: 'inherit' });
        logSuccess('图标创建完成');
    } catch (error) {
        logWarning('图标创建失败，将使用默认图标');
    }
}

// 安装依赖
function installDependencies() {
    logStep('3', '安装依赖包...');
    
    try {
        log('正在安装 Electron 和构建工具...', colors.blue);
        execSync('npm install', { stdio: 'inherit' });
        logSuccess('依赖安装完成');
    } catch (error) {
        logError('依赖安装失败');
        throw error;
    }
}

// 构建应用
function buildApplication(platform = 'current') {
    logStep('4', `构建应用程序 (${platform})...`);
    
    const buildCommands = {
        'current': 'npm run build',
        'windows': 'npm run build:win',
        'mac': 'npm run build:mac',
        'linux': 'npm run build:linux',
        'all': 'npm run build:win && npm run build:mac && npm run build:linux'
    };
    
    const command = buildCommands[platform] || buildCommands['current'];
    
    try {
        log(`执行命令: ${command}`, colors.blue);
        execSync(command, { stdio: 'inherit' });
        logSuccess(`${platform} 平台构建完成`);
    } catch (error) {
        logError(`${platform} 平台构建失败`);
        throw error;
    }
}

// 清理构建文件
function cleanBuild() {
    logStep('Clean', '清理构建文件...');
    
    const dirsToClean = ['dist', 'build', 'node_modules/.cache'];
    
    dirsToClean.forEach(dir => {
        if (fs.existsSync(dir)) {
            try {
                execSync(`rimraf ${dir}`, { stdio: 'inherit' });
                logSuccess(`清理 ${dir}`);
            } catch (error) {
                logWarning(`无法清理 ${dir}`);
            }
        }
    });
}

// 显示构建信息
function showBuildInfo() {
    logStep('Info', '构建信息');
    
    try {
        const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
        
        log(`\n${colors.bright}应用信息:${colors.reset}`);
        log(`  名称: ${packageJson.name}`);
        log(`  版本: ${packageJson.version}`);
        log(`  描述: ${packageJson.description}`);
        
        log(`\n${colors.bright}构建目标:${colors.reset}`);
        log(`  Windows: NSIS安装包 + 便携版`);
        log(`  macOS: DMG镜像文件`);
        log(`  Linux: AppImage + DEB包`);
        
        log(`\n${colors.bright}输出目录:${colors.reset}`);
        log(`  ./dist/ - 所有构建文件`);
        
    } catch (error) {
        logWarning('无法读取package.json信息');
    }
}

// 主函数
function main() {
    const args = process.argv.slice(2);
    const command = args[0] || 'build';
    const platform = args[1] || 'current';
    
    log(`\n${colors.bright}智能薪资计算器 - 构建脚本${colors.reset}`, colors.magenta);
    log('='.repeat(50));
    
    try {
        switch (command) {
            case 'clean':
                cleanBuild();
                break;
                
            case 'info':
                showBuildInfo();
                break;
                
            case 'icons':
                createIcons();
                break;
                
            case 'install':
                installDependencies();
                break;
                
            case 'build':
            default:
                checkRequiredFiles();
                createIcons();
                installDependencies();
                buildApplication(platform);
                
                log(`\n${colors.bright}构建完成！${colors.reset}`, colors.green);
                log('构建文件位于 ./dist/ 目录');
                break;
        }
        
    } catch (error) {
        logError(`构建失败: ${error.message}`);
        process.exit(1);
    }
}

// 显示帮助信息
function showHelp() {
    log(`\n${colors.bright}使用方法:${colors.reset}`);
    log('  node build.js [command] [platform]');
    log('');
    log(`${colors.bright}命令:${colors.reset}`);
    log('  build     - 构建应用程序 (默认)');
    log('  clean     - 清理构建文件');
    log('  icons     - 创建应用图标');
    log('  install   - 安装依赖包');
    log('  info      - 显示构建信息');
    log('  help      - 显示帮助信息');
    log('');
    log(`${colors.bright}平台:${colors.reset}`);
    log('  current   - 当前平台 (默认)');
    log('  windows   - Windows平台');
    log('  mac       - macOS平台');
    log('  linux     - Linux平台');
    log('  all       - 所有平台');
    log('');
    log(`${colors.bright}示例:${colors.reset}`);
    log('  node build.js build windows');
    log('  node build.js clean');
    log('  node build.js info');
}

// 检查是否需要显示帮助
if (process.argv.includes('--help') || process.argv.includes('-h')) {
    showHelp();
} else {
    main();
}
